package iotest;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

/**
 * 文件流的演示
 * 文件流的输入\inputStream
 * 文件流的输出\outputStream
 * 文件流是连接程序和文件的通道，向文件写入或者写出
 * 文件流是字节流，字符流
 * 文件流，缓冲流，对象流
 * ；流的分类：
 * 1. 按照功能：输入流，输出流
 *      输入流：inOUtputStream,Reader
 *      输出流：inOUtputStream,Writer
 * 2. 按照数据类型分：字节流，字符流
 *      字节流：文件流，缓冲流，对象流
 *      字符流：
 * 3. 按照级别分：低级流，高级流
 *      低级流：文件流
 *      高级流：其它
 *
 *
 */
public class FileDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //文件输出流
        FileOutputStream fos=new FileOutputStream("fos.dat");
        fos.write(1);
        fos.write(2);
        System.out.println("写入成功");
        fos.close();
        //文件输入流
        FileInputStream fis=new FileInputStream("fos.dat");
        int d=fis.read();
        System.out.println(d);
        //按照字节读取文字
        d=fis.read();
        System.out.println(d);
        d=fis.read();
        System.out.println(d);
        //读取到文件末尾时会返回-1
        //练习单字节的读写
        FileInputStream fis1=new FileInputStream("img.png");
        FileOutputStream fos1=new FileOutputStream("img_text.png");
        //定义时间段来记录执行时间
        long star=System.currentTimeMillis();
        int len=0;
        while ((len=fis1.read())!=-1){//读取一个字节
            fos1.write(len);
        }
        long end =System.currentTimeMillis();
        System.out.println("执行完成！执行时间："+(end-star)+"ms");
        fis1.close();
        fos1.close();
        //练习块级的读写
        //输入流对象
        FileInputStream fis2=new FileInputStream("img.png");
        FileOutputStream fos2=new FileOutputStream("img_text2.png");
        byte[] data=new byte[1024*10];//10kb
        long star1=System.currentTimeMillis();
        int len1=0;
        while ((len1=fis2.read(data))!=-1){
            fos2.write(data);
        }
        long end1=System.currentTimeMillis();
        System.out.println("执行完成！执行时间："+(end1-star1)+"ms");
        fis2.close();
        fos2.close();
        //
        //字符串的写入和写出
        //输入输出流对象
        File file=new File("fos.dat");
        FileInputStream fis3=new FileInputStream(file);
        FileOutputStream fos3=new FileOutputStream("fos.dat");
        String str="字符串的练习按字节流输入和输出!!!!";
        //字符串转byte[]数组 按照UTF_8进行转换
        byte[] data1=str.getBytes(StandardCharsets.UTF_8);
        //write
        fos3.write(data1);
        //write out again
        str="hello world";
        data1=str.getBytes(StandardCharsets.UTF_8);
        fos3.write(data1);
        System.out.println("写入成功");
        fos3.close();
        //读取
        byte[] data2=new byte[(int)file.length()];
        fis3.read(data2);//读取文件到data2
        String str1=new String(data2,StandardCharsets.UTF_8);
        System.out.println(str1);
        fis3.close();
        //简单的记事本
        File file1=new File("note.txt");
        FileInputStream fis4=new FileInputStream(file1);
        FileOutputStream fos4=new FileOutputStream(file1);
        //写入
        Scanner scan=new Scanner(System.in);
        while (true){
            System.out.println("请输入内容：");
            String nodedata=scan.nextLine();
            if ("exit".equals(nodedata)){
                break;
            }
            byte[] data3=nodedata.getBytes(StandardCharsets.UTF_8);
            fos4.write(data3);
        }
        System.out.println("退出记事本");
        fos4.close();
        //读取记事本内容
        byte[] data4=new byte[(int)file1.length()];
        fis4.read(data4);
        String nodetext=new String(data4,StandardCharsets.UTF_8);
        System.out.println("记事本的内容"+nodetext);
        fis4.close();
        //练习BufferedOutputStream,BufferedInputStream
        //使用缓冲流读取文件，提高文件的处理效率
        //输入
        File file2=new File("img.png");
        FileInputStream fis5=new FileInputStream(file2);
        BufferedInputStream bis=new BufferedInputStream(fis5);
        //输出
        FileOutputStream fos5=new FileOutputStream("img_text3.png");
        BufferedOutputStream bos=new BufferedOutputStream(fos5);
        int len2=0;
        while ((len2=bis.read())!=-1){
            bos.write(len2);
        }
        System.out.println("用buffered缓冲流复制成功");
        bis.close();
        bos.close();
        System.out.println("------------------");

        //缓冲取的数据问题，flush()解决方案
        //当写入缓冲区时，数据并没有写入到文件，当缓冲区满了，才会将缓冲区中的数据写入到文件
        // 或者调用flush()方法时，才会将缓冲区中的数据写入到文件
        //因此当不满缓冲区时，写入的数据也想到文件，需要调用flush()方法
        FileOutputStream fos6=new FileOutputStream("fos.dat");
        BufferedOutputStream bos1=new BufferedOutputStream(fos6);
        String str2="hello world";
        byte[] data5=str2.getBytes(StandardCharsets.UTF_8);
        bos1.write(data5);
        bos1.flush();//即使数据不满也可以写入到文件
        System.out.println("写入成功");
        //
        //写入对象----对象的序列化与反序列化-----对象流
        Person person=new Person("张三",18,"男",new String[]{"1","2","3"});
        FileOutputStream fos7=new FileOutputStream("person.obj");
        ObjectOutputStream oos=new ObjectOutputStream(fos7);
        //序列化
        oos.writeObject(person);
        //需要类实现一下Serializable接口
        System.out.println("序列化成功");
        oos.close();
        //反序列化
        FileInputStream fis6=new FileInputStream("person.obj");
        ObjectInputStream ois=new ObjectInputStream(fis6);
        Person person1=(Person) ois.readObject();
        System.out.println(person1);
        ois.close();





    }
}
